
//public class test {
//
//    final V putVal(K key, V value, boolean onlyIfAbsent) {
////        如果key或val为空，抛出异常
//        if (key == null || value == null) throw new NullPointerException();
////        计算hash值
//        int hash = spread(key.hashCode());
//        int binCount = 0;
//        for (ConcurrentHashMap.Node<K, V>[] tab = table; ; ) {
//            ConcurrentHashMap.Node<K, V> f;
//            int n, i, fh;
//            K fk;
//            V fv;
////            如果tab不存在或长度为0，就初始化
//            if (tab == null || (n = tab.length) == 0)
//                tab = initTable();
//
//            else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
//                if (casTabAt(tab, i, null, new ConcurrentHashMap.Node<K, V>(hash, key, value)))
//                    break;                   // no lock when adding to empty bin
////                如果表正在扩容
//            } else if ((fh = f.hash) == MOVED)
//                tab = helpTransfer(tab, f);
//            else if (onlyIfAbsent // check first node without acquiring lock
//                    && fh == hash
//                    && ((fk = f.key) == key || (fk != null && key.equals(fk)))
//                    && (fv = f.val) != null)
//                return fv;
////            如果表不为空且没有其他线程在扩容
//            else {
//                V oldVal = null;
////                对根节点进行加锁
//                synchronized (f) {
//                    if (tabAt(tab, i) == f) {
////                        fh大于等于0说明是链表
//                        if (fh >= 0) {
//                            binCount = 1;
//                            for (ConcurrentHashMap.Node<K, V> e = f; ; ++binCount) {
//                                K ek;
//                                if (e.hash == hash &&
//                                        ((ek = e.key) == key ||
//                                                (ek != null && key.equals(ek)))) {
//                                    oldVal = e.val;
//                                    if (!onlyIfAbsent)
//                                        e.val = value;
//                                    break;
//                                }
//                                ConcurrentHashMap.Node<K, V> pred = e;
//                                if ((e = e.next) == null) {
//                                    pred.next = new ConcurrentHashMap.Node<K, V>(hash, key, value);
//                                    break;
//                                }
//                            }
////                            如果是红黑树
//                        } else if (f instanceof ConcurrentHashMap.TreeBin) {
//                            ConcurrentHashMap.Node<K, V> p;
//                            binCount = 2;
//                            if ((p = ((ConcurrentHashMap.TreeBin<K, V>) f).putTreeVal(hash, key,
//                                    value)) != null) {
//                                oldVal = p.val;
//                                if (!onlyIfAbsent)
//                                    p.val = value;
//                            }
//                        } else if (f instanceof ConcurrentHashMap.ReservationNode)
//                            throw new IllegalStateException("Recursive update");
//                    }
//                }
//                if (binCount != 0) {
//                    if (binCount >= TREEIFY_THRESHOLD)
//                        treeifyBin(tab, i);
//                    if (oldVal != null)
//                        return oldVal;
//                    break;
//                }
//            }
//        }
//        addCount(1L, binCount);
//        return null;
//    }
//}
